home *** CD-ROM | disk | FTP | other *** search
/ Languguage OS 2 / Languguage OS II Version 10-94 (Knowledge Media)(1994).ISO / gnu / libg_261.zip / libg_261 / libg++ / etc / trie-gen / options.cc < prev    next >
C/C++ Source or Header  |  1992-03-07  |  5KB  |  207 lines
  1. /* Handles parsing the Options provided to the user.
  2.    Copyright (C) 1989 Free Software Foundation, Inc.
  3.    written by Douglas C. Schmidt (schmidt@ics.uci.edu)
  4.  
  5. This file is part of GNU TRIE-GEN.
  6.  
  7. GNU TRIE-GEN is free software; you can redistribute it and/or modify
  8. it under the terms of the GNU General Public License as published by
  9. the Free Software Foundation; either version 1, or (at your option)
  10. any later version.
  11.  
  12. GNU TRIE-GEN is distributed in the hope that it will be useful,
  13. but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15. GNU General Public License for more details.
  16.  
  17. You should have received a copy of the GNU General Public License
  18. along with GNU TRIE-GEN; see the file COPYING.  If not, write to
  19. the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  20.  
  21. #include <stdio.h>
  22. #include <builtin.h>
  23. #include <assert.h>
  24. #include <stdarg.h>
  25. #include <GetOpt.h>
  26. #include "options.h"
  27.  
  28. /* Global option coordinator for the entire program. */
  29. Options option;       
  30.  
  31. /* Current program version. */
  32. extern char *version_string;
  33.  
  34. static void
  35. report_error (const char *format, ...)
  36. {
  37.   va_list args;
  38.   va_start (args, format);
  39.   char c;
  40.  
  41.   while (c = *format++)
  42.     {
  43.       if (c=='%')
  44.         switch (c = *format++)
  45.           {
  46.           case 'a':
  47.             exit (1);
  48.           case 'n':
  49.             fputs (option.program_name (), stderr);
  50.             break;
  51.           case 'e':
  52.             typedef void (*CallbackT) (void);
  53.             CallbackT callback = va_arg (args, CallbackT);
  54.             (*callback) ();
  55.             break;
  56.           case 's':
  57.             fputs (va_arg (args, const char *), stderr);
  58.             break;
  59.           default:
  60.             fputc (c, stderr);
  61.           }
  62.       else
  63.         fputc (c, stderr);
  64.     }
  65.   va_end (args);
  66. }
  67.  
  68. /* Prints program usage to standard error stream. */
  69.  
  70. inline void 
  71. Options::usage (void) 
  72. { 
  73.   report_error ("Usage: %n [-cdf] (type %n -h for help)\n");
  74. }
  75.  
  76. /* Output command-line Options. */
  77.  
  78. void 
  79. Options::print_options (void)
  80. { 
  81.   int i;
  82.  
  83.   printf ("/* Command-line: ");
  84.  
  85.   for (i = 0; i < argument_count; i++) 
  86.     printf ("%s ", argument_vector[i]);
  87.    
  88.   printf (" */");
  89. }
  90. /* Sets the default Options. */
  91.  
  92. int     Options::option_word = 0; 
  93. int     Options::argument_count = 0;
  94. char ** Options::argument_vector = 0;
  95.  
  96. Options::Options (void) 
  97. { 
  98.   option_word = 0;
  99. }
  100.  
  101. /* Dumps option status when debug is set. */
  102.  
  103. Options::~Options (void) 
  104. { 
  105.   if (option_word & DEBUG)
  106.     {
  107.       fprintf (stderr, "\ndumping Options:\nCOMPACT is.......: %s\nDEBUG is.......: %s"
  108.                "\nFULL is........: %s\nCONST is.......: %s",
  109.                option_word & COMPACT ? "enabled" : "disabled",
  110.                option_word & DEBUG ? "enabled" : "disabled",
  111.                option_word & FULL ? "enabled" : "disabled",
  112.                option_word & CONST ? "enabled" : "disabled");
  113.  
  114.       fprintf (stderr, "\nfinished dumping Options\n");
  115.     }
  116. }
  117.  
  118.  
  119. /* Parses the command line Options and sets appropriate flags in option_word. */
  120.  
  121. void 
  122. Options::operator () (int argc, char *argv[])
  123. { 
  124.   GetOpt getopt (argc, argv, "cCdfh");
  125.   int    option_char;
  126.  
  127.   argument_count = argc;
  128.   argument_vector = argv;
  129.  
  130.   while ((option_char = getopt ()) != EOF)
  131.     {
  132.       switch (option_char)
  133.         {
  134.         case 'c':               /* Compact the output tables. */
  135.           {
  136.             option_word |= COMPACT;
  137.             break;
  138.           }
  139.         case 'C':               /* Make the generated tables readonly (const). */
  140.           {
  141.             option_word |= CONST;
  142.             break;
  143.           }
  144.         case 'd':               /* Enable debugging option. */
  145.           { 
  146.             option_word |= DEBUG;
  147.             report_error ("Starting program %n, version %s, with debuggin on.\n",
  148.                           version_string);
  149.             break;
  150.           }   
  151.         case 'f':               /* Generate a full table */
  152.           {
  153.             option_word |= FULL;
  154.             break;
  155.           }
  156.         case 'h':
  157.           {
  158.             report_error ("-c\tCompact the generated trie.\n"
  159.                           "-C\tMake strings in the generated lookup table constant, i.e., readonly.\n"
  160.                           "-d\tEnable debugging (produces verbose output to standard error).\n"
  161.                           "-f\tGenerates a `full' trie rather than a minimal-prefix trie.\n"
  162.                           "-h\tPrints out the help diagnostic.\n%a");
  163.           }
  164.         default: 
  165.           report_error ("%e%a", usage);
  166.         }
  167.     }
  168.   
  169.   if (argv[getopt.optind] && ! freopen (argv[getopt.optind], "r", stdin))
  170.     report_error ("Unable to read key word file %s.\n%e%a", argv[getopt.optind], usage);
  171.   
  172.   if (++getopt.optind < argc) 
  173.     report_error ("Extra trailing arguments to %n.\n%e%a", usage);
  174. }
  175.  
  176. #ifndef __OPTIMIZE__
  177. const char *
  178. Options::program_name (void)
  179. {
  180.   return argument_vector[0];
  181. }
  182.  
  183. /* TRUE if option enable, else FALSE. */
  184. int  
  185. Options::operator[] (Option_Type option) 
  186. { 
  187.   return option_word & option;
  188. }
  189.  
  190. /* Enables option OPT. */
  191. void
  192. Options::operator= (enum Option_Type opt) 
  193. {
  194.   option_word |= opt;
  195. }
  196.  
  197. /* Disables option OPT. */
  198. void
  199. Options::operator!= (enum Option_Type opt) 
  200. {
  201.   option_word &= ~opt;
  202. }
  203.  
  204. #endif /* not defined __OPTIMIZE__ */
  205.  
  206.  
  207.